//package com.demo.base.redis;
//
//import com.demo.base.common.acs.OSSFileUtils;
//import com.demo.base.dto.allot.AllotDto;
//import com.demo.base.dto.allot.AllotStrategyDto;
//import com.demo.base.dto.common.LoginLogDto;
//import com.demo.base.dto.common.OpLogDto;
//import com.demo.base.dto.content.IndexDataDto;
//import com.demo.base.dto.content.ModuleDto;
//import com.demo.base.dto.course.CourseCategoryDto;
//import com.demo.base.dto.course.CourseChapterPeriodDto;
//import com.demo.base.dto.group.GroupCategoryDto;
//import com.demo.base.dto.problem.ProblemAnswerDto;
//import com.demo.base.enums.CourseTypeEnum;
//import com.demo.base.enums.ShareTypeEnum;
//import com.demo.base.json.JSON;
//import com.demo.base.utils.DateUtils;
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.data.redis.core.Cursor;
//import org.springframework.data.redis.core.ScanOptions;
//import org.springframework.data.redis.core.StringRedisTemplate;
//import org.springframework.util.StringUtils;
//
//import java.util.ArrayList;
//import java.util.Date;
//import java.util.List;
//import java.util.Set;
//import java.util.concurrent.TimeUnit;
//import java.util.stream.Collectors;
//
///**
// * created by shiwf on 2018/3/24
// **/
//public class RedisHelper {
//    Logger logger = LoggerFactory.getLogger(getClass());
//
//    private static final String STATISTICS_PREFIX = "live:statistics";
//    private static final String RELATION_PREFIX = "live:relation";
//    private static final String ANSWER_PREFIX = "live:answer";
//    private static final String GROUP_OWNER_PREFIX = "live:group:owner";
//    private static final String USER_REDIS_KEY_PREFIX = "live:user";
//    private static final String COURSE_CATEGORY_REDIS_KEY_PREFIX = "live:course:category";
//    private static final String GROUP_CATEGORY_REDIS_KEY_PREFIX = "live:group:category";
//    private static final String SILENT_USER_KEY_PREFIX = "live:user:silent";
//    private static final String LIVE_MICRO_COURSE_MERGER = "live:course:message:voiceMerger";
//    private static final String SILENT_ALLOT_PREFIX = "live:allot";
//    private static final String POSTER_PREFIX = "live:poster";
//    private static final String LOGIN_LOG_PREFIX = "live:log:login";
//    private static final String OPERATE_LOG_PREFIX = "live:log:operate";
//    private static final String INDEX_SORT_KEY = "live:index:sort";
//    private static final String INDEX_DATA_KEY = "live:index:data";
//    private static final String COURSE_MEMBER_PREFIX = "live:course:member";
//    private static final String COURSE_MEMBER_LIST_KEY = "live:course:member:list";
//    private static final String COURSE_ONLINETIME_LIST_KEY = "live:course:onlinetime:list";
//    private static final String COURSE_PREVIEW_PREFIX = "live:course:preview";
//    private static final String COURSE_USER_MAX_ONLINE_PREFIX = "socket:room:user:max_online_user";
//    private static final String ROBOT_MAX_NUM_KEY = "live:user:robot_max_num";
//
//
//    StringRedisTemplate redisTemplate;
//
//    public RedisHelper(StringRedisTemplate redisTemplate) {
//        this.redisTemplate = redisTemplate;
//    }
//
//    private class RelationData {
//        private ClassifyEnum classify;
//        private String bizId;
//        private String refId;
//
//        public RelationData(ClassifyEnum classify, String bizId, String refId) {
//            this.classify = classify;
//            this.bizId = bizId;
//            this.refId = refId;
//        }
//
//        public ClassifyEnum getClassify() {
//            return classify;
//        }
//
//        public void setClassify(ClassifyEnum classify) {
//            this.classify = classify;
//        }
//
//        public String getBizId() {
//            return bizId;
//        }
//
//        public void setBizId(String bizId) {
//            this.bizId = bizId;
//        }
//
//        public String getRefId() {
//            return refId;
//        }
//
//        public void setRefId(String refId) {
//            this.refId = refId;
//        }
//
//        public void addRedis() {
//            redisTemplate.opsForValue().set(key(), String.valueOf(System.currentTimeMillis()));
//        }
//
//        public void removeRedis() {
//            redisTemplate.delete(key());
//        }
//
//        public boolean getRedis() {
//            return redisTemplate.hasKey(key());
//        }
//
//        public int count() {
//            String key = key();
//            return redisTemplate.keys(key).size();
//        }
//
//        private String key() {
//            return append(RELATION_PREFIX, this.getClassify().name(), this.getBizId(), this.getRefId());
//        }
//
//    }
//
//    private class StatisticsData {
//        private ModuleEnum module;
//        private String bizId;
//        private ClassifyEnum classify;
//        private long count;
//
//        public StatisticsData(ModuleEnum module, String bizId, ClassifyEnum statisticsType, long count) {
//            this.module = module;
//            this.bizId = bizId;
//            this.classify = statisticsType;
//            this.count = count;
//        }
//
//        public StatisticsData(ModuleEnum module, String bizId, ClassifyEnum classify) {
//            this.module = module;
//            this.bizId = bizId;
//            this.classify = classify;
//        }
//
//        public ModuleEnum getModule() {
//            return module;
//        }
//
//        public void setModule(ModuleEnum module) {
//            this.module = module;
//        }
//
//        public String getBizId() {
//            return bizId;
//        }
//
//        public void setBizId(String bizId) {
//            this.bizId = bizId;
//        }
//
//        public ClassifyEnum getClassify() {
//            return classify;
//        }
//
//        public void setClassify(ClassifyEnum classify) {
//            this.classify = classify;
//        }
//
//        public long getCount() {
//            return count;
//        }
//
//        public void setCount(long count) {
//            this.count = count;
//        }
//
//        public void addRedis() {
//            redisTemplate.opsForValue().set(key(), String.valueOf(this.getCount()));
//        }
//
//        public long getRedis() {
//            String key = key();
//            return redisTemplate.hasKey(key) ? Integer.parseInt(redisTemplate.opsForValue().get(key)) : 0L;
//        }
//
//        public void clean() {
//            String key = key();
//            Set<String> keys = redisTemplate.keys(key);
//            redisTemplate.delete(keys);
//        }
//
//        private String key() {
//            return append(STATISTICS_PREFIX, this.getModule().name(), this.getBizId(), this.getClassify().name());
//        }
//
//    }
//
//    /**
//     * live-直播, course-课程, group-圈子, topic-帖子, problem-问答, user-用户
//     */
//    enum ModuleEnum {
//        live, course, group, topic, problem, user
//    }
//
//    /**
//     * praise-点赞, follow-关注, member-成员, order-订单, attend-参与,quiz-问答,course_count-课程数据,micro_count-微课数量
//     */
//    public enum ClassifyEnum {
//        praise, follow, member, order, attend, quiz, course_count, micro_count
//    }
//
//    private String append(String... key) {
//        return String.join(":", key);
//    }
//
//
//    /*****************************************清除数据关联数据************************************************/
//    public void clear(String key) {
//        if (!StringUtils.isEmpty(key)) {
//            ScanOptions options = ScanOptions.scanOptions().match(key + "*").count(10000).build();
//            Cursor c = redisTemplate.getConnectionFactory().getConnection().scan(options);
//            List<String> keys = new ArrayList<>();
//            int count = 0;
//            while (c.hasNext()) {
//                keys.add(new String((byte[]) c.next()));
//                count++;
//                if (count == 10000) {
//                    redisTemplate.delete(keys);
//                    logger.info("delete key from redis, keySet={}", keys.stream().collect(Collectors.joining(",")));
//                    count = 0;
//                    keys.clear();
//                }
//            }
//            redisTemplate.delete(keys);
//        }
//    }
//
//    public void clearRelate(ClassifyEnum classify) {
//        Set<String> keys = redisTemplate.opsForValue().getOperations().keys(append(RELATION_PREFIX, null == classify ? "*" : classify.name(), "*"));
//        redisTemplate.delete(keys);
//    }
//    /*****************************************记录关联数据************************************************/
//    /**
//     * 点赞/取消点赞/查询关联
//     *
//     * @param userId   点赞用户
//     * @param praiseId 点赞业务id
//     */
//    public void addPraiseRelate(String userId, String praiseId) {
//        new RelationData(ClassifyEnum.praise, userId, praiseId).addRedis();
//    }
//
//    public void delPraiseRelate(String userId, String praiseId) {
//        new RelationData(ClassifyEnum.praise, userId, praiseId).removeRedis();
//    }
//
//    public boolean getPraiseRelate(String userId, String praiseId) {
//        return new RelationData(ClassifyEnum.praise, userId, praiseId).getRedis();
//    }
//
//    public int countPraiseRelate(String userId, String praiseId) {
//        return new RelationData(ClassifyEnum.praise, userId, praiseId).count();
//    }
//
//    public void clearPraiseRelate() {
//        Set<String> keys = redisTemplate.opsForValue().getOperations().keys(append(RELATION_PREFIX, ClassifyEnum.praise.name(), "*"));
//        redisTemplate.delete(keys);
//    }
//
//    /**
//     * 关注/取消关注/查询关联
//     *
//     * @param userId   用户
//     * @param followId 关注用户
//     */
//    public void addFollowRelate(String userId, String followId) {
//        new RelationData(ClassifyEnum.follow, userId, followId).addRedis();
//    }
//
//    public void delFollowRelate(String userId, String followId) {
//        new RelationData(ClassifyEnum.follow, userId, followId).removeRedis();
//    }
//
//    public boolean getFollowRelate(String userId, String followId) {
//        return new RelationData(ClassifyEnum.follow, userId, followId).getRedis();
//    }
//
//    public int countFollowRelate(String userId, String followId) {
//        return new RelationData(ClassifyEnum.follow, userId, followId).count();
//    }
//
//    public void clearFollowRelate() {
//        Set<String> keys = redisTemplate.opsForValue().getOperations().keys(append(RELATION_PREFIX, ClassifyEnum.follow.name(), "*"));
//        redisTemplate.delete(keys);
//    }
//
//    /**
//     * 添加成员关联/取消添加成员关联/查询添加成员关联
//     *
//     * @param userId     用户
//     * @param resourceId 资源id
//     */
//    public void addMemberRelate(String userId, String resourceId) {
//        new RelationData(ClassifyEnum.member, userId, resourceId).addRedis();
//    }
//
//    public void delMemberRelate(String userId, String resourceId) {
//        new RelationData(ClassifyEnum.member, userId, resourceId).removeRedis();
//    }
//
//    public boolean getMemberRelate(String userId, String resourceId) {
//        return new RelationData(ClassifyEnum.member, userId, resourceId).getRedis();
//    }
//
//    public int countMemberRelate(String userId, String resourceId) {
//        return new RelationData(ClassifyEnum.member, userId, resourceId).count();
//    }
//
//    public void clearMemberRelate() {
//        Set<String> keys = redisTemplate.opsForValue().getOperations().keys(append(RELATION_PREFIX, ClassifyEnum.member.name(), "*"));
//        redisTemplate.delete(keys);
//    }
//
//    /***************************************记录统计数据**************************************************/
//
//    /**
//     * 记录直播相关数目
//     *
//     * @param liveId   id
//     * @param classify 统计类型
//     * @param count    数量
//     */
//    public void addLiveCount(String liveId, ClassifyEnum classify, long count) {
//        new StatisticsData(ModuleEnum.live, liveId, classify, count).addRedis();
//    }
//
//    public long getLiveCount(String liveId, ClassifyEnum classify) {
//        return new StatisticsData(ModuleEnum.live, liveId, classify).getRedis();
//    }
//
//    /**
//     * 记录圈子相关数目
//     *
//     * @param groupId  id
//     * @param classify 统计类型
//     * @param count    数量
//     */
//    public void addGroupCount(String groupId, ClassifyEnum classify, long count) {
//        new StatisticsData(ModuleEnum.group, groupId, classify, count).addRedis();
//    }
//
//    public long getGoupCount(String groupId, ClassifyEnum classify) {
//        return new StatisticsData(ModuleEnum.group, groupId, classify).getRedis();
//    }
//
//    /**
//     * 记录问答相关数目
//     *
//     * @param problemId 问答id
//     * @param classify  统计类型
//     * @param count     数量
//     */
//    public void addProblemCount(String problemId, ClassifyEnum classify, long count) {
//        new StatisticsData(ModuleEnum.problem, problemId, classify, count).addRedis();
//    }
//
//    public long getProblemCount(String problemId, ClassifyEnum classify) {
//        return new StatisticsData(ModuleEnum.problem, problemId, classify).getRedis();
//    }
//
//    /**
//     * 记录用户相关数目
//     *
//     * @param userId   用户id
//     * @param classify 统计类型
//     * @param count    数量
//     */
//    public void addUserCount(String userId, ClassifyEnum classify, long count) {
//        new StatisticsData(ModuleEnum.user, userId, classify, count).addRedis();
//    }
//
//    public long getUserCount(String userId, ClassifyEnum classify) {
//        return new StatisticsData(ModuleEnum.user, userId, classify).getRedis();
//    }
//
//    public void cleanUserCount(ClassifyEnum classify) {
//        new StatisticsData(ModuleEnum.user, "*", classify).clean();
//    }
//
//    /**
//     * 记录用户相关数目
//     *
//     * @param courseId 课程
//     * @param classify 统计类型
//     * @param count    数量
//     */
//    public void addCourseCount(String courseId, ClassifyEnum classify, long count) {
//        new StatisticsData(ModuleEnum.course, courseId, classify, count).addRedis();
//    }
//
//    public long getCourseCount(String courseId, ClassifyEnum classify) {
//        return new StatisticsData(ModuleEnum.course, courseId, classify).getRedis();
//    }
//
//    /********************************业务数据缓存***********************************/
//
//    /*记录问题答案*/
//    public void addProblemAnswer(ProblemAnswerDto answer) {
//        redisTemplate.opsForValue().set(append(ANSWER_PREFIX, answer.getProblemId()), JSON.toJSONString(answer));
//    }
//
//    public void removeProblemAnswer(String problemId) {
//        redisTemplate.delete(append(ANSWER_PREFIX, problemId));
//    }
//
//    /*记录用户个人圈子id*/
//    public void addUserOwningGroup(String userId, String groupId) {
//        redisTemplate.opsForValue().set(append(GROUP_OWNER_PREFIX, userId), groupId);
//    }
//
//    public String getUserOwningGroup(String userId) {
//        String key = append(GROUP_OWNER_PREFIX, userId);
//        return redisTemplate.hasKey(key) ? redisTemplate.opsForValue().get(key) : "";
//    }
//
//    public void clearUserOwningGroup() {
//        Set<String> keys = redisTemplate.opsForValue().getOperations().keys(append(GROUP_OWNER_PREFIX, "*"));
//        redisTemplate.delete(keys);
//    }
//
////    /*记录用户*/
////    public void addUserInfo(UserInfoDto user) {
////        if (null != user) {
////            redisTemplate.opsForValue().set(append(USER_REDIS_KEY_PREFIX, user.getId()), com.alibaba.fastjson.JSON.toJSONString(user));
////        }
////    }
////
////    /*删除用户缓存*/
////    public void removeUserInfo(String userId) {
////        if (!StringUtils.isEmpty(userId)) {
////            redisTemplate.delete(append(USER_REDIS_KEY_PREFIX, userId));
////        }
////    }
////
////    public UserInfoDto getUserInfo(String userId) {
////        if (redisTemplate.hasKey(append(USER_REDIS_KEY_PREFIX, userId))) {
////            String userJson = redisTemplate.opsForValue().get(append(USER_REDIS_KEY_PREFIX, userId));
////            return JSON.parseObject(userJson, UserInfoDto.class);
////        }
////        return null;
////    }
//
//    /* 记录禁言用户 */
//    public void addSilentUser(String userId, String resourceId, long expire) {
//        String redisKey = append(SILENT_USER_KEY_PREFIX, userId, resourceId);
//        redisTemplate.opsForValue().set(redisKey, System.currentTimeMillis() + "", expire);
//    }
//
//    public void removeSilentUser(String userId, String resourceId) {
//        String redisKey = append(SILENT_USER_KEY_PREFIX, userId, resourceId);
//        redisTemplate.delete(redisKey);
//    }
//
//    public boolean checkSilentUser(String userId, String resourceId) {
//        String redisKey = append(SILENT_USER_KEY_PREFIX, userId, resourceId);
//        return redisTemplate.hasKey(redisKey);
//    }
//
//    /* 微课合成语音 */
//    public void setMicroCourseAudio(String courseId, String url) {
//        String key = append(LIVE_MICRO_COURSE_MERGER, courseId);
//        redisTemplate.opsForValue().set(key, url);
//    }
//
//    public String getMicroCourseAudio(String courseId) {
//        String key = append(LIVE_MICRO_COURSE_MERGER, courseId);
//        return redisTemplate.hasKey(key) ? OSSFileUtils.computeFullPath(redisTemplate.opsForValue().get(key)) : "";
//    }
//
//    /* 试听课程 */
//    public void addCoursePreview(String courseId, CourseChapterPeriodDto period) {
//        String key = append(COURSE_PREVIEW_PREFIX, courseId);
//        redisTemplate.opsForValue().set(key, JSON.toJSONString(period));
//    }
//
//    public CourseChapterPeriodDto getCoursePreview(String courseId) {
//        String key = append(COURSE_PREVIEW_PREFIX, courseId);
//        String json = redisTemplate.opsForValue().get(key);
//        if (!StringUtils.isEmpty(json)) {
//            return JSON.parseObject(json, CourseChapterPeriodDto.class);
//        }
//        return null;
//    }
//
//    public void clearCoursePreview(String courseId) {
//        String key = append(COURSE_PREVIEW_PREFIX, StringUtils.isEmpty(courseId) ? "*" : courseId);
//        Set<String> keys = redisTemplate.opsForValue().getOperations().keys(key);
//        redisTemplate.delete(keys);
//    }
//
//    /* 海报地址 */
//    public void setPosterUrl(String key, String url, long expire) {
//        if (expire <= 0) {
//            expire = 3600 * 24 * 30;//一个月
//        }
//        if (!StringUtils.isEmpty(url)) {
//            redisTemplate.opsForValue().set(append(POSTER_PREFIX, key), url, expire, TimeUnit.SECONDS);
//        }
//    }
//
//    public String getPosterUrl(String key) {
//        String redisKey = append(POSTER_PREFIX, key);
//        return redisTemplate.hasKey(redisKey) ? OSSFileUtils.computeFullPath(redisTemplate.opsForValue().get(redisKey)) : "";
//    }
//
//    public void clearPosterUrl(String key) {
//        String redisKey = append(POSTER_PREFIX, key);
//        redisTemplate.delete(redisKey);
//    }
//
//    public void setPosterTemplate(ShareTypeEnum type, String data) {
//        redisTemplate.opsForValue().set(append(POSTER_PREFIX, type.name()), data);
//    }
//
//    public String getPosterTemplate(ShareTypeEnum type) {
//        String redisKey = append(POSTER_PREFIX, type.name());
//        return redisTemplate.hasKey(redisKey) ? OSSFileUtils.computeFullPath(redisTemplate.opsForValue().get(redisKey)) : "";
//    }
//
//    public void setPosterTemplateConfig(String posterId, String data) {
//        redisTemplate.opsForValue().set(append(POSTER_PREFIX, posterId), data);
//    }
//
//    public String getPosterTemplateConfig(String posterId) {
//        return redisTemplate.opsForValue().get(append(POSTER_PREFIX, posterId));
//    }
//
//
//    /***
//     * 记录分成,类型，用户，资源id,strategy资源josn
//     */
//    public void addAllotStrategy(AllotDto allot) {
//        String redisKey = append(SILENT_ALLOT_PREFIX, allot.getResourceType().name(), allot.getUserId(), allot.getResourceId());
//        redisTemplate.opsForValue().set(redisKey, allot.getAllotStrategy());
//    }
//
//    public AllotStrategyDto getAllotStrategy(AllotDto allot) {
//        String redisKey = append(SILENT_ALLOT_PREFIX, allot.getResourceType().name(), allot.getUserId(), allot.getResourceId());
//        if (redisTemplate.hasKey(redisKey)) {
//            return JSON.parseObject(redisTemplate.opsForValue().get(redisKey), AllotStrategyDto.class);
//        } else {
//            return null;
//        }
//    }
//
//    /**
//     * 日志缓存
//     */
//    public void addLoginLog(LoginLogDto log) {
//        redisTemplate.opsForValue().set(append(LOGIN_LOG_PREFIX, log.getId()), JSON.toJSONString(log));
//    }
//
//    public List<LoginLogDto> getLoginLog() {
//        Set<String> keys = redisTemplate.keys(append(LOGIN_LOG_PREFIX, "*"));
//        List<String> values = redisTemplate.opsForValue().multiGet(keys);
//        List<LoginLogDto> logs = values.stream().map(v -> JSON.parseObject(v, LoginLogDto.class)).collect(Collectors.toList());
//        return logs;
//    }
//
//    public void deleteLoginLog(List<String> ids) {
//        List<String> keys = ids.stream().map(k -> append(LOGIN_LOG_PREFIX, k)).collect(Collectors.toList());
//        redisTemplate.delete(keys);
//    }
//
//    public void addOpLog(OpLogDto log) {
//        redisTemplate.opsForValue().set(append(OPERATE_LOG_PREFIX, log.getId()), JSON.toJSONString(log));
//    }
//
//    public List<OpLogDto> getOpLog() {
//        Set<String> keys = redisTemplate.keys(append(OPERATE_LOG_PREFIX, "*"));
//        List<String> values = redisTemplate.opsForValue().multiGet(keys);
//        List<OpLogDto> logs = values.stream().map(v -> JSON.parseObject(v, OpLogDto.class)).collect(Collectors.toList());
//        return logs;
//    }
//
//    public void deleteOpLog(List<String> ids) {
//        List<String> keys = ids.stream().map(k -> append(OPERATE_LOG_PREFIX, k)).collect(Collectors.toList());
//        redisTemplate.delete(keys);
//    }
//
//    public Long lockReward(String key, long timeout) {
//        Long lock = redisTemplate.opsForValue().increment(key, 1);
//        if (1 == lock) {
//            redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
//        }
//        return lock;
//    }
//
//    public void unlockReward(String key) {
//        redisTemplate.delete(key);
//    }
//
//    /**
//     * 保存首页推荐缓存数据
//     *
//     * @param indexDataDto
//     */
//    public void setIndexData(IndexDataDto indexDataDto) {
//        redisTemplate.opsForValue().set(INDEX_DATA_KEY, JSON.toJSONString(indexDataDto));
//    }
//
//    /**
//     * 获取首页推荐缓存数据
//     *
//     * @return
//     */
//    public IndexDataDto getIndexData() {
//        String str = redisTemplate.opsForValue().get(INDEX_DATA_KEY);
//        return null != str ? JSON.parseObject(str, IndexDataDto.class) : null;
//    }
//
//    /**
//     * 删除首页推荐缓存数据
//     */
//    public void delIndexData() {
//        redisTemplate.delete(INDEX_DATA_KEY);
//    }
//
//    /**
//     * 保存首页推荐排序缓存
//     *
//     * @param sorts
//     */
//    public void setIndexSort(String type, List<ModuleDto> sorts) {
//        redisTemplate.opsForValue().set(INDEX_SORT_KEY + ":" + type, JSON.toJSONString(sorts));
//    }
//
//    /**
//     * 获取首页推荐排序缓存
//     *
//     * @return
//     */
//    public List<ModuleDto> getIndexSort(String type) {
//        String str = redisTemplate.opsForValue().get(INDEX_SORT_KEY + ":" + type);
//        return null != str ? JSON.parseArray(str, ModuleDto.class) : null;
//    }
//
//    /**
//     * 删除首页推荐缓存排序
//     */
//    public void delIndexSort(String type) {
//        redisTemplate.delete(INDEX_SORT_KEY + ":" + type);
//    }
//
//    /**
//     * 判断是否有课程成员数据
//     *
//     * @param courseId
//     * @return
//     */
//    public boolean existCourseMember(String courseId) {
//        String key = append(COURSE_MEMBER_PREFIX, courseId);
//        return redisTemplate.hasKey(key);
//    }
//
//    /**
//     *  初始化课程成员数据
//     *
//     * @param courseId
//     * @param userIds
//     * @return
//     */
//    public boolean initCourseMember(String courseId, Set<String> userIds) {
//        String key = append(COURSE_MEMBER_PREFIX, courseId);
//        redisTemplate.expire(key, 600, TimeUnit.SECONDS);
//        userIds.forEach(it -> redisTemplate.opsForSet().add(key, it));
//        return true;
//    }
//
//    /**
//     * 课程加入成员
//     *
//     * @param courseId
//     * @param userId
//     * @return
//     */
//    public boolean addCourseMember(String courseId, String userId) {
//        String key = append(COURSE_MEMBER_PREFIX, courseId);
//        boolean exist = redisTemplate.opsForSet().isMember(key, userId);
//        if (!exist) {
//            redisTemplate.opsForSet().add(key, userId);
//            return true;
//        }
//        return false;
//    }
//
//    /**
//     * 锁
//     *
//     * @param key     字段名
//     * @param timeout 锁时长
//     * @return 1表示没有锁（当前进程锁定），大于1表示被其他进程占用
//     */
//    public Long lock(String key, long timeout) {
//        Long lock = redisTemplate.opsForValue().increment(key, 1);
//        if (1 == lock) {
//            redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
//        }
//        return lock;
//    }
//
//    /**
//     * 解锁
//     *
//     * @param key 字段名
//     */
//    public void unlock(String key) {
//        redisTemplate.delete(key);
//    }
//
//
//    /**
//     * 课程成员加入队列
//     *
//     * @param courseId   课程id
//     * @param userId     用户id
//     * @param createTime 加入时间
//     */
//    public void lpushCourseMember(String courseId, String userId, Date createTime) {
//        String createTimeStr = DateUtils.formatDate(createTime, "yyyy-MM-dd HH:mm");
//        String value = courseId + "#" + userId + "@" + createTimeStr;
//        redisTemplate.opsForList().leftPush(COURSE_MEMBER_LIST_KEY, value);
//    }
//
//    /**
//     * 课程成员加入队列
//     *
//     * @param courseId 课程id
//     * @param userId   用户id
//     */
//    public void lpushCourseMember(String courseId, String userId) {
//        this.lpushCourseMember(courseId, userId, new Date());
//    }
//
//    /**
//     * 从队列获取课程成员
//     *
//     * @return
//     */
//    public String rpopCourseMember() {
//        return redisTemplate.opsForList().rightPop(COURSE_MEMBER_LIST_KEY);
//    }
//
//    /**
//     * 在线时间加入队列
//     *
//     * @param courseId   课程id
//     * @param userId     用户id
//     * @param onlineTime 在线时间秒
//     */
//    public void lpushCourseOnlineTime(String courseId, String userId, int onlineTime) {
//        String value = courseId + "@" + userId + "#" + onlineTime;
//        redisTemplate.opsForList().leftPush(COURSE_ONLINETIME_LIST_KEY, value);
//    }
//
//    /**
//     * 从队列获取在线时间
//     *
//     * @return
//     */
//    public String rpopCourseOnlineTime() {
//        return redisTemplate.opsForList().rightPop(COURSE_ONLINETIME_LIST_KEY);
//    }
//
//    public int getCourseMaxOnlineUser(String courseId) {
//        String key = append(COURSE_USER_MAX_ONLINE_PREFIX, courseId);
//        return redisTemplate.hasKey(key) ? Integer.parseInt(redisTemplate.opsForValue().get(key)) : 0;
//    }
//
//    public void clearCourseMaxOnlineUser(String courseId) {
//        String key = append(COURSE_USER_MAX_ONLINE_PREFIX, courseId);
//        redisTemplate.delete(key);
//    }
//
//    /******************************************数据刷新*********************************************************/
//
//
//    public void refreshCourseCategory(CourseTypeEnum type, List<CourseCategoryDto> list) {
//        Set<String> keys = redisTemplate.opsForValue().getOperations().keys(append(COURSE_CATEGORY_REDIS_KEY_PREFIX, type.toString(), "*"));
//        //清除redis中的课程分类
//        redisTemplate.delete(keys);
//        for (CourseCategoryDto dto : list) {
//            redisTemplate.opsForValue().set(append(COURSE_CATEGORY_REDIS_KEY_PREFIX, type.toString(), dto.getId()), JSON.toJSONString(dto));
//        }
//    }
//
//    /**
//     * 刷新圈子分类
//     *
//     * @param list
//     */
//    public void refreshGroupCategory(List<GroupCategoryDto> list) {
//        Set<String> keys = redisTemplate.opsForValue().getOperations().keys(append(GROUP_CATEGORY_REDIS_KEY_PREFIX, "*"));
//        //清除redis中的圈子分类
//        redisTemplate.delete(keys);
//        for (GroupCategoryDto dto : list) {
//            redisTemplate.opsForValue().set(append(GROUP_CATEGORY_REDIS_KEY_PREFIX, dto.getId()), JSON.toJSONString(dto));
//        }
//    }
//
//    public boolean hasKey(String key) {
//        return redisTemplate.hasKey(key);
//    }
//
//
//    public Long getMaxRobotNum() {
//        String str = redisTemplate.opsForValue().get(ROBOT_MAX_NUM_KEY);
//        if (null != str) {
//            return Long.parseLong(str);
//        }
//        return null;
//    }
//
//    public void setMaxRobotNum(long num) {
//        redisTemplate.opsForValue().set(ROBOT_MAX_NUM_KEY, num + "");
//    }
//}
